Distributed Implementation of SIGNAL: Scheduling & Graph Clustering

International audienceThis paper introduces the scheduling strategy and some key tools which have been designed for the distributed implementation of Signal, a real-time synchronous dataflow language. First, we motivate a scheduling strategy with respect to the reactivity and time-predictability requirements bound to real-time computing. Then, several key tools to implement this scheduling strategy are described. These tools are acting on the concept of Synchronous-Flow Dependence Graph (SFD Graph) which defines a generalization of Directed Acyclic Graph and constitutes the abstract representation of Signal programs. The tools presented in this paper are: (a) the abstraction of SFD graphs which enables grain-size tuning according to the target architecture, (b) the notion of scheduling over SFD graphs and (c) qualitative clustering tools based on the notion of Compositional Deadlock Consistency

An algebraic theory for behavioral modeling and protocol synthesis in system design

International audienceThe design productivity gap has been recognized by the semiconductor industry as one of the major threats to the continued growth of system-on-chips and embedded systems. Ad-hoc system-level design methodologies, that lifts modeling to higher levels of abstraction, and the concept of intellectual property (IP), that promotes reuse of existing components, are essential steps to manage design complexity. However, the issue of compositional correctness arises with these steps. Given components from different manufacturers, designed with heterogeneous models, at different levels of abstraction, assembling them in a correct-by-construction manner is a difficult challenge. We address this challenge by proposing a process algebraic model to support system design with a formal model of computation and serve as a type system to capture the behavior of system components at the interface level. The proposed algebra is conceptually minimal, equipped with a formal semantics defined in a synchronous model of computation. It supports a scalable notion and a flexible degree of abstraction. We demonstrate its benefits by considering the type-based synthesis of latency-insensitive protocols, showing that the synthesis of component wrappers can be optimized by behavioral information carried by interface type descriptions and yield minimized stalls and maximized throughput

Toward Static Analysis of SIGNAL Programs using Interval Techniques

International audienceThis paper presents a work-in-progress aiming at improving the functional analysis of Signal programs. The usual adopted technique relies on abstractions. Typically, in order to check the presence or absence of variables in a program at some logical instants, the program is transformed into another program that reflects its clock information so that the presence or absence of each variable can be straightforwardly checked. Signal adopts a boolean abstraction for the static functional analysis of programs. This abstraction does not enable to fully reason on the values of non logical variables. Here, we propose a solution based on interval techniques in order to be able to deal with both logical and numerical parts of programs

Synchronous programming with events and relations: the SIGNAL language and its semantics

AbstractIn this paper, systems which interact permanently with their environment are considered. Such systems are encountered, for instance, in real-time control or signal processing systems, C3-systems, man-machine interfaces, to mention just a few. The design and implementation of such systems require a concurrent programming language which can be used to verify and synthesize the synchronization mechanisms, and to perform transformations of the concurrent source code to match a particular target architecture. Synchronous languages are convenient tools for such a purpose: they rely on the assumption that: (1) internal actions of synchronous systems are instantaneous, and (2) communication with the environment is performed via instantaneous flashes involving some external stimuli. In this paper, we present a synchronous programming language: SIGNAL. A SIGNAL program specifies dynamical relations between (internal and external) signal flows. The SIGNAL compiler checks deadlock and determinism of the program, and produces an intermediate level code equivalent to a nested family of concurrent automata. The compilation algorithm is supported by: (1) a behavioural semantics of SIGNAL programs in terms of conditional rewriting rules, (2) the coding of this semantics into the skew product of a dynamical system over the field of integers modulo 3 and directed graphs, (3) an algebraic algorithm to transform the above coding into an equivalent executable one, which provides by the way an execution semantics of the language. We briefly discuss the implementation aspects, and explain the capabilities and limitations of the current version of the SIGNAL compiler

Real-time,synchronous,data-flow programming: the language "SIGNAL" and its mathematical semantics

Disponible dans les fichiers attachés à ce documen

Hybrid dynamical systems theory and the language "SIGNAL"

Disponible dans les fichiers attachés à ce documen

Synchronous design of avionic applications based on model refinements

International audienceIn this article, we address the design of avionic applications based on an approach, which relies on model refinement. This study is done within the synchronous framework, which has solid mathematical foundations enabling formal methods for specification, verification and analysis, transformations, etc. In the proposed approach, we first consider a functional description of a given application using the SIGNAL language. This description is independent of a specific implementation platform. Then, some transformations that fully preserve the semantics of manipulated SIGNAL programs are applied to the description such that a representation reflecting an integrated modular avionics architecture results

Semi-granules and schielding for off-line scheduling

In the framework of parallel programming, we use a type of directed graph, which we call the pin-graph, as a model for various applications : the vertices represent the elementary tasks ; the arcs represent the internal dependences ; and the pins represent communication with the outside. The connectivity of pins-graphs is studied in order to classify them into two classes. A pin-graph in the first class is called a semi-granule. The elementary tasks of a semi-granule can be ordered into a sequential scheduled such that no dead-lock due to this sequential schedule can appear ; a schedule that has this last property is called a circuit-consistent schedule. A pin-graph that is not a semi-granule does not have any so scheduled. A partition into semi-granules of a pin-graph in this class is computed. The tasks of every so obtained semi-granule are well-ordered into a circuit-consistent schedule ; and the composition of these schedules builds up a circuit-consistent schedule of the whole pin-graph, which thus cannot generate any dead-lock, whatever the context. Algorithms partitioning pin-graphs into semi-granules are surveyed

Compositional design of isochronous systems

International audienceThe synchronous modeling paradigm provides strong correctness guarantees for embedded system design while requiring minimal environmental assumptions. In most related frameworks, global execution correctness is achieved by ensuring the insensitivity of (logical) time in the program from (real) time in the environment. This property, called endochrony or patience, can be statically checked, making it fast to ensure design correctness. Unfortunately, it is not preserved by composition, which makes it difficult to exploit with component-based design concepts in mind. Compositionality can be achieved by weakening this objective, but at the cost of an exhaustive state-space exploration. This raises a trade-off between performance and precision. Our aim is to balance it by proposing a formal design methodology that adheres to a weakened global design objective: the non-blocking composition of weakly endochronous processes, while preserving local design objectives for synchronous modules. This yields an effective and cost-efficient approach to compositional synchronous modeling

An Example of Synchronous Design of Embedded Real-Time Systems based on IMA

International audienceWe present a study on the design of embedded real-time systems in general, and avionic systems in particular. The synchronous language Signal is used to describe a real world avionic application based on the recent Integrated Modular Avionics concept (IMA). The exposed case study shows how the synchronous technology helps for a reliable and modular design of real-time systems. One major advantage of this technology is the availability of formal tools and techniques for verification and validation, which are important for safety-critical systems such as avionics systems